package arithmeticSortList2;

import utils.PrintUtil;

/*
 * 冒泡排序
 *
 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
 * 针对所有的元素重复以上的步骤，除了最后一个。
 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 * @param numbers 需要排序的整型数组
 */
public class MaoPao {
    public static int[] originNum;

    static {
        originNum = new int[10];
        for (int i = 0; i < originNum.length; i++) {
            originNum[i] = (int) (1000 * Math.random());
            System.err.print(originNum[i] + ",");
        }

    }

    public static void main(String[] args) {

        //开启线程
        Runnable runnable = new Runnable() {
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("--");
                    //开始排序
                    int[] bubbleSort = bubbleSort(originNum);

                    for (int i = 0; i < bubbleSort.length; i++) {
                        System.out.print(bubbleSort[i] + ",");
                    }

                    System.out.println();
                    int[] bubbleSortIndex = bubbleSortIndex(originNum);

                    for (int i = 0; i < bubbleSortIndex.length; i++) {
                        Thread.sleep(2);
                        System.out.print(bubbleSortIndex[i] + ",");
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        };
        runnable.run();
    }


    /*
     * 冒泡排序
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
     *
     * fori //0-》n 找 n 次最大值。
     *  forj 交换每个元素。
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。
     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
     *
     * @param numbers 需要排序的整型数组
     * n^2
     */
    public static int[] bubbleSort(int[] numbers) {
        if (numbers == null || numbers.length < 1) return numbers;
        int temp = 0;
        int size = numbers.length;
        for (int i = 0; i < size - 1; i++) {//0-》n 找 n 次最大值。
            for (int j = 0; j < size - 1 - i; j++) {// 交换每个元素。
                if (numbers[j] > numbers[j + 1]) {
                    temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }
        return numbers;
    }

    //交换index， 每次一找到最大值而已。
    public static int[] bubbleSortIndex(int[] numbers) {
        int size = numbers.length;
        for (int i = 0; i < size; i++) {
            int maxIndex = 0;
            for (int j = 1; j < size - i; j++) {
                if (numbers[j] > numbers[maxIndex]) {
                    maxIndex = j;
                }
            }
            int index = size - 1 - i;
            if (maxIndex != (index)) {
                int temp = numbers[index];
                numbers[index] = numbers[maxIndex];
                numbers[maxIndex] = temp;
            }
        }
        return numbers;

    }

}
